import api from './api.js'
import { smisConfig } from '../config/apiConfig.js'

/**
 * 数据服务类，用于处理API数据获取和管理
 */
export class DataService {
  /**
   * 获取数据from指定的API端点
   * @param {string} endpoint - API端点URL
   * @param {Object} params - 查询参数
   * @returns {Promise<Object>} 返回API响应数据
   */
  static async fetchData(endpoint, params = {}) {
    try {
      const response = await api.get(endpoint, { params })
      return {
        success: true,
        data: response,
        error: null
      }
    } catch (error) {
      return {
        success: false,
        data: null,
        error: error.message || '数据获取失败'
      }
    }
  }

  /**
   * 发送POST请求
   * @param {string} endpoint - API端点URL
   * @param {Object} data - 请求数据
   * @returns {Promise<Object>} 返回API响应数据
   */
  static async postData(endpoint, data = {}) {
    try {
      const response = await api.post(endpoint, data)
      return {
        success: true,
        data: response,
        error: null
      }
    } catch (error) {
      return {
        success: false,
        data: null,
        error: error.message || '数据提交失败'
      }
    }
  }

  /**
   * 处理多个API请求
   * @param {Array} requests - 请求配置数组
   * @returns {Promise<Array>} 返回所有请求的结果
   */
  static async batchRequests(requests) {
    try {
      const promises = requests.map(request => 
        this.fetchData(request.endpoint, request.params)
      )
      const results = await Promise.allSettled(promises)
      return results.map(result => result.value || result.reason)
    } catch (error) {
      return []
    }
  }

  /**
   * 获取SMIS配料岛原始数据（通过代理）
   * @returns {Promise<Object>} 返回SMIS原始数据
   */
  static async fetchSmisRawData() {
    try {
      // 使用代理路径，避免CORS问题
      const proxyUrl = `/api/smis/materialstock?warehousecode=${smisConfig.defaultParams.warehousecode}`
      
      const response = await fetch(proxyUrl, {
        method: 'GET',
        headers: {
          'Content-Type': 'application/json',
          'Accept': 'application/json'
        }
      })

      if (!response.ok) {
        throw new Error(`SMIS数据获取失败: ${response.status} ${response.statusText}`)
      }

      const data = await response.json()
      
      return {
        success: true,
        data: data,
        error: null
      }
    } catch (error) {
      return {
        success: false,
        data: null,
        error: error.message || 'SMIS数据获取失败'
      }
    }
  }

  /**
   * 获取SMIS配料岛库存数据（前端过滤）
   * @param {Object} params - 查询参数 {itemCode, lotCode}
   * @returns {Promise<Object>} 返回过滤后的SMIS库存数据
   */
  static async fetchSmisStock(params = {}) {
    try {
      // 获取原始数据
      const rawDataResult = await this.fetchSmisRawData()
      
      if (!rawDataResult.success) {
        return rawDataResult
      }
      
      const rawData = rawDataResult.data
      const itemCode = params.itemCode || ''
      const lotCode = params.lotCode || ''
      
      // 如果没有查询条件，返回所有数据
      if (!itemCode.trim()) {
        return {
          success: true,
          data: { data: rawData },
          error: null
        }
      }
      
      // 前端过滤数据 - 处理直接返回的数组或包装在对象中的数组
      let dataArray = rawData
      if (!Array.isArray(rawData)) {
        // 如果数据被包装在对象中，尝试提取数组
        if (rawData.data && Array.isArray(rawData.data)) {
          dataArray = rawData.data
        } else {
          return {
            success: false,
            data: null,
            error: 'SMIS数据格式不正确：期望数组格式'
          }
        }
      }
      
      if (!Array.isArray(dataArray)) {
        return {
          success: false,
          data: null,
          error: 'SMIS数据格式不正确：无法解析为数组'
        }
      }
      
      const itemCodes = itemCode.split(',').map(code => code.trim()).filter(code => code)
      
      const filteredData = dataArray.filter(item => {
        const materialCode = item.materialcode || ''
        const vendorLot = item.venderlot || ''
        
        // 检查物料编码匹配
        const itemMatches = itemCodes.some(code => materialCode === code)
        
        // 检查批次号匹配（如果有批次号条件）
        const lotMatches = !lotCode.trim() || vendorLot === lotCode.trim()
        
        return itemMatches && lotMatches
      })
      
      return {
        success: true,
        data: { data: filteredData },
        error: null
      }
      
    } catch (error) {
      return {
        success: false,
        data: null,
        error: error.message || 'SMIS配料岛数据获取失败'
      }
    }
  }
}

export default DataService
